/* Die Klasse Benutzer repraesentiert einen Benutzer des Systems, alle  
 * dafuer benoetigten Daten werden in der Klasse gespeichert. Ausserdem
 * werden benoetigte Dienste zur Verfuegung gestellt
 * 
 * Datei: Benutzer.java                Autor:   Antonia Wagner 
 * Datum: 02.11.11                     Version: 0.8 
 * 
 * Historie: 02.11.11 v0.1 von Autor: Get- und Set-Methoden fuer id, 
 *                         geburtsname, loginName, loginPasswort und
 *			                   gebDatum erstellt
 *	         05.11.11 v0.2 von Autor: weitere Get- und Set-Methoden 
 *		                     erstellt Methode initialisieren(),
 *			                   nummerHinzufuegen(), neueNotizHinzufuegen()
 *           11.11.11 v0.3 von Autor: speichern einer ID beim Erzeugen
 *                         eines Benutzers hinzugefuegt, Methoden zum
 *                         ausleihen, zurueckgeben und reservieren 
 *                         eines Mediums implementiert, Moeglichkeit 
 *                         einen Anschaffungsvorschlag zu machen
 *                         implementiert
 *           29.11.11 v0.4 Methoden istAdministrator(), istStudent() 
 *                         und istMitarbeiter() eingefuegt
 *           09.12.11 v0.5 Einfuegen der privaten Klasse 
 *                         Authentifizierung und Anpassung der Methoden
 *           10.12.11 v0.6 Fehler beim Vergleich des gespeicherten und 
 *                         des eingegebenen Passworts behoben
 *           27.12.11 v0.7 Fehlermeldungen bei Falscheingabe des Namens
 *                         implementiert
 *           29.12.11 v0.8 Bezahlen der Mahnung implementiert
 */

package personenverwaltung;

import java.util.ArrayList;
import java.util.List;

import kommunikation.Adresse;
import kommunikation.Email;
import kommunikation.Notiz;
import kommunikation.Postfachadresse;
import kommunikation.Telefonnummer;
import kommunikation.Wohnsitzadresse;
import medienverwaltung.EAN13;
import medienverwaltung.Exemplar;
import GUI.Dashboard;
import basis.lokal.Lokalisierung;
import basis.lokal.Sprachen;
import bestellungsverwaltung.Mahnung;
import bestellungsverwaltung.Mahnungsverwaltung;

public class Benutzer extends Person
{

  /*
   * Definition der Konstanten
   */
  private static final long serialVersionUID = 8173912915585415126L;

  /*
   * Definition der Attribute
   */
  private int id;
  private String geburtsname;
  private List<Adresse> adressListe;
  private List<Telefonnummer> telefonnumernListe;
  private List<Email> emailListe;
  private List<Notiz> notizListe;
  private Datum gebDatum;
  private Rechte recht;
  private String loginName;
  private String loginPasswort;
  private List<MedienVorgang> ausleihListe;
  private List<MedienVorgang> reservierungsListe;
  private Adresse adresse;
  private Mahnung mahnung;
  private Benutzer.Authentifizierung authentifizierung;
  private Lokalisierung lokal;


  public Benutzer (String name, String nachname)
  {
    super (name, nachname);
    initialisieren ();
  }


  public Benutzer (String name, String nachname, Datum gebDatum)
  {
    super (name, nachname);
    initialisieren ();
    this.setzeGebDatum (gebDatum);
  }


  public Benutzer (String name, String nachname, Datum gebDatum,
      String ort, String plz, String strasse, String hausnummer)
  {
    super (name, nachname);
    initialisieren ();
    setzeGebDatum (gebDatum);
    wohnsitzadresseHinzufuegen (ort, plz, strasse, hausnummer);
  }


  public Benutzer (String name, String nachname, Datum gebDatum,
      String ort, String plz, String strasse, String hausnummer,
      String telefonnummer)
  {
    super (name, nachname);
    initialisieren ();
    setzeGebDatum (gebDatum);
    wohnsitzadresseHinzufuegen (ort, plz, strasse, hausnummer);
    nummerHinzufuegen (telefonnummer);
  }


  /**
   * @return ID des Benutzers
   */
  public int gibId ()
  {
    return id;
  }


  /**
   * 
   * @param id
   *          des Benutzers
   */
  public void setzeId (int id)
  {
    this.id = id;
  }


  /**
   * 
   * @return Login-Name des Benutzers
   */
  public String gibLoginName ()
  {
    return loginName;
  }


  /**
   * 
   * @param loginName
   *          des Benutzers kann gespeichert werden
   */
  public void setzeLoginName (String loginName)
  {
    this.loginName = loginName;
  }


  /**
   * 
   * @return geburtsname des Benutzers
   */
  public String gibGeburtsname ()
  {
    return geburtsname;
  }


  /**
   * Der Geburtsname des Benutzers kann ueber diese Methode gestezt
   * werden
   * 
   * @param geburtsname
   */
  public void setzeGeburtsname (String geburtsname)
  {
    String name = istGueltigerName (geburtsname);
    if (name != null)
    {
      this.geburtsname = name;
    }
    else
    {
      Benutzermeldung.fehlermeldungZeigen (
          lokal.gibUebersetzung ("Falscheingabe Name"),
          lokal.gibUebersetzung ("Fehler"));
    }
  }


  /**
   * 
   * @return Passwort des Benutzers, verschluesselt
   */
  private String gibLoginPasswort ()
  {
    return loginPasswort;
  }


  /**
   * 
   * @param loginPasswort
   *          des Benutzers, wenn es gesetzt oder geaendert werden soll
   */
  private void setzeLoginPasswort (String loginPasswort)
  {
    this.loginPasswort = loginPasswort;
  }


  /**
   * 
   * @return das Geburtsdatum des Benutzers
   */
  public Datum gibGebDatum ()
  {
    return gebDatum;
  }


  /**
   * 
   * @param gebDatum
   *          des Benutzers
   */
  private void setzeGebDatum (Datum gebDatum)
  {
    this.gebDatum = gebDatum;

    /*
     * Das Standard-Passwort wird beim Erstellen des Benutzers
     * automatisch erzeugt und gespeichert. Es wird das Geburtsdatum
     * verwendet
     */
    authentifizierung.passwortSetzen (gebDatum.toString ());
  }


  /**
   * 
   * @return die Liste der gespeicherten Adressen des Benutzers
   */
  public List<Adresse> gibAdressListe ()
  {
    return adressListe;
  }


  /**
   * 
   * @param adressListe
   *          eine Liste der Adressen eines Benutzers kann gesetzt
   *          werden
   */
  public void setzeAdressListe (List<Adresse> adressListe)
  {
    this.adressListe = adressListe;
  }


  /**
   * 
   * @return eine Liste von E-Mail-Adressen, die zu dem Benutzer
   *         gespeichert sind
   */
  public List<Email> gibEmailListe ()
  {
    return emailListe;
  }


  /**
   * 
   * @param emailListe
   *          eine Liste der E-Mail-Adressen eines Benutzers kann
   *          gesetzt werden
   */
  public void setzeEmailListe (List<Email> emailListe)
  {
    this.emailListe = emailListe;
  }


  /**
   * 
   * @return die Rechte des Benutzers
   */
  public Rechte gibRechte ()
  {
    return recht;
  }


  /**
   * 
   * @param recht
   *          der Administrator kann ueber diese Methode die Rechte des
   *          Benutzers aendern
   */
  public void setzeRechte (Rechte recht)
  {
    this.recht = recht;
  }


  /**
   * 
   * @return eine Liste von Medien, die der Benutzer zum Zeitpunkt der
   *         Abfrage ausgeliehen hat
   */
  public List<MedienVorgang> gibAusleihListe ()
  {
    return ausleihListe;
  }


  /**
   * 
   * @param ausleihListe
   *          eine Liste von Ausleihungen kann auch gesetzt werden
   */
  public void setzeAusleihListe (List<MedienVorgang> ausleihListe)
  {
    this.ausleihListe = ausleihListe;
  }


  /**
   * 
   * @return die gespeicherte Haupt-Adresse
   */
  public Adresse gibHauptAdresse ()
  {
    return adresse;
  }


  /**
   * 
   * @param adresse
   *          die zu speichernde Haupt-Adresse
   */
  public void wohnsitzadresseHinzufuegen (String ort, String plz,
      String strasse, String hausnummer)
  {
    Adresse adresse = new Wohnsitzadresse (ort, plz, hausnummer,
        strasse);
    adressListe.add (adresse);

    this.adresse = adresse;
  }


  /**
   * Diese Methode ermoeglicht es, eine Adresse mit Postfach beim
   * Benutzer zu hinterlegen
   * 
   * @param ort
   *          der Ort der Adresse
   * @param plz
   *          die Postleitzahl der Adresse
   * @param postfach
   *          das Postfach der Adresse
   */
  public void postfachadresseHinzufuegen (String ort, String plz,
      String postfach)
  {
    adresse = new Postfachadresse (ort, plz, postfach);
    adressListe.add (adresse);
  }


  /**
   * 
   * @return eine Liste mit zu dem Benutzer gespeicherten Notizen
   */
  public List<Notiz> gibNotizen ()
  {
    return notizListe;
  }


  /**
   * mit dieser Methode ist das Erstellen einer neuen Notiz zur Person
   * moeglich
   * 
   * @param text
   *          Inhalt der Notiz
   * @param mitarbeiter
   *          Mitarbeiter, der die Notiz erstellt hat
   */
  public void notizHinzufuegen (String text, Benutzer mitarbeiter)
  {
    Notiz notiz = new Notiz (text, mitarbeiter);
    notizListe.add (notiz);
  }


  /**
   * 
   * @return eine Liste von Medien, die der Benutzer zum Zeitpunkt der
   *         Abfrage reserviert hat
   */
  public List<MedienVorgang> gibReservierungsListe ()
  {
    return reservierungsListe;
  }


  /**
   * 
   * @param reservierungsListe
   *          eine Liste mit Reservierungen, die einem Benutzer
   *          zugeordnet werden sollen
   */
  public void setzeReservierungsListe (
      List<MedienVorgang> reservierungsListe)
  {
    this.reservierungsListe = reservierungsListe;
  }


  /**
   * 
   * @param ausleihe
   *          der Ausleihvorgang, der erzeugt wird, wenn der Benutzer
   *          ein Medium ausleihen will
   */
  public void ausleihen (Ausleihe ausleihe)
  {
    ausleihListe.add (ausleihe);
  }


  /**
   * @param exemplar
   *          fuer das die Ausleihe verlaengert werden soll
   * 
   */
  public void ausleiheVerlaengern (Exemplar exemplar)
  {
    Ausleihe ausleihe = (Ausleihe) findeVorgang (exemplar, "Ausleihe");
    ausleiheVerlaengern (ausleihe);
  }


  /**
   * 
   * @param ausleihe
   *          die verlaengert werden soll
   */
  public void ausleiheVerlaengern (Ausleihe ausleihe)
  {
    ausleihe.verlaengern ();
  }


  /**
   * 
   * @param rueckgabe
   *          der Rueckgabevorgang, der erzeugt wird, wenn der Benutzer
   *          ein Medium abgeben moechte
   * 
   * @throws ExemplarNichtAusgeliehenAusnahme
   */
  public void abgeben (Rueckgabe rueckgabe)
  {
    Exemplar exemplar = rueckgabe.gibExemplar ();
    Ausleihe ausleihe = (Ausleihe) findeVorgang (exemplar, "Ausleihe");

    if (ausleihe != null)
    {
      ausleihe.setzeAbgeschlossen ();
      ausleihListe.remove (ausleihe);
    }
    else
    {
      throw new ExemplarNichtAusgeliehenAusnahme ();
    }
  }


  /**
   * 
   * @param reservierung
   *          die Reservierung, die erzeugt wird, wenn der
   */
  public void reservieren (Reservierung reservierung)
  {
    if (reservierung == null)
    {
      throw new ParameterIstNullAusnahme ();
    }
    reservierungsListe.add (reservierung);
  }


  /**
   * Hebt die Reservierung eines Exemplars auf
   * 
   * @param exemplar
   *          dessen Reservierung aufgehoben werden soll
   */
  public void reservierungAufheben (Exemplar exemplar)
  {
    reservierungsListe.remove (exemplar);
  }


  /**
   * Hebt die Reservierung eines Exemplars auf
   * 
   * @param res
   *          die aufgehoben werden soll
   */
  public void reservierungAufheben (Reservierung res)
  {
    Exemplar ex = res.gibExemplar ();
    reservierungAufheben (ex);
  }


  /**
   * Methode berechnet bei Bedarf, ob der Benutzer volljaehrig ist
   */
  public boolean istVolljaehrig ()
      throws KeinGeburtsdatumGesetztAusnahme
  {
    if (gebDatum == null)
    {
      throw new KeinGeburtsdatumGesetztAusnahme ();
    }
    return Datum.istVolljaehrig (gebDatum);
  }


  /**
   * Diese Methode dient zum Hinzufuegen einer E-Mail-Adresse
   * 
   * @param email
   *          Adresse des Benutzers
   */
  public void emailHinzufuegen (String email)
  {
    Email mail = new Email (email);
    emailListe.add (mail);
  }


  /**
   * 
   * @param email
   *          die geloescht werden soll
   */
  public void emailLoeschen (String email)
  {
    emailListe.remove (email);
  }


  /**
   * Ermoeglicht es, eine Telefonnummer zu speichern
   * 
   * @param nummer
   *          die bei dem Benutzer hinterlegt werden soll
   */
  public void nummerHinzufuegen (String nummer)
  {
    Telefonnummer nr = new Telefonnummer (nummer);
    telefonnumernListe.add (nr);
  }


  /**
   * 
   * @param nummer
   *          die geloescht werden soll
   */
  public void nummerLoeschen (String nummer)
  {
    telefonnumernListe.remove (nummer);
  }


  /**
   * 
   * @return die aktuell zu dem Benutzer gespeicherte Mahnung
   */
  public Mahnung gibMahnung ()
  {
    return mahnung;
  }


  /**
   * 
   * @param m
   *          speichert eine Mahnung, die bei ueberschreitung der
   *          Ausleihfrist erzeugt wird
   */
  public void setzeMahnung (Mahnung m)
  {
    this.mahnung = m;
    recht.setzAusleihberechtigung (false);
  }


  /**
   * @return den bool-Wert, ob der Benutzer eine offene Mahnung hat
   */
  public boolean hatOffeneMahnung ()
  {
    if ((mahnung == null) || (mahnung.gibmahngebuer () == 0))
    {
      mahnung = null;
      recht.setzAusleihberechtigung (true);
      return false;
    }
    else
    {
      return true;
    }
  }


  /**
   * 
   * @return die Hoehe der aktuell bei dem Benutzer hinterlegten Mahn-
   *         gebuehren
   */
  public double gibMahngebuehr ()
  {
    if (mahnung == null)
    {
      return 0.0;
    }
    else
    {
      return mahnung.gibmahngebuer ();
    }
  }


  public void mahngebuehrBezahlen (double betrag)
  {
    if ((mahnung == null) || (mahnung.gibmahngebuer () == 0))
    {
      throw new KeineGebuehrVorhandenAusnahme ();
    }
    else
    {
      Mahnungsverwaltung mVerwaltung = new Mahnungsverwaltung ();
      mVerwaltung.mahngebuehrBezahlen (betrag, this);

      double offeneGebuehr = mahnung.gibmahngebuer ();

      Benutzermeldung.informationZeigen (
          lokal.gibUebersetzung ("Mahngebuehr bezahlt" + offeneGebuehr
              + "EUR"), lokal.gibUebersetzung ("Info"));

      /*
       * Gespeicherte Mahnung loeschen, wenn sie bezahlt ist
       */
      if (offeneGebuehr == 0.0)
      {
        mahnung = null;
      }
    }
  }


  /**
   * @return einen bool-Wert, ob der Benutzer ein Medium ausleihen darf
   */
  public boolean istAusleihberechtigt ()
  {
    if ( (mahnung == null) || (mahnung.gibmahngebuer () == 0))
    {
      return recht.darfAusleihen ();
    }
    else
    {
      return false;
    }
  }


  /**
   * 
   * @return einen bool-Wert, ob der Benutzer ein Medium reservieren
   *         darf
   */
  public boolean istReservierungsberechtig ()
  {
    return recht.darfReservieren ();
  }


  /**
   * 
   * @return die Liste der hinterlegten Telefonnummern
   */
  public List<Telefonnummer> gibTelefonnummernListe ()
  {
    return telefonnumernListe;
  }


  /**
   * 
   * @param telefonnumernListe
   *          die Liste der hinterlegten Telefonnummern
   */
  public void setzeTelefonnummernListe (
      List<Telefonnummer> telefonnumernListe)
  {
    this.telefonnumernListe = telefonnumernListe;
  }


  /**
   * 
   * @return ob der Benutzer ein Mitarbeiter ist
   */
  public boolean istMitarbeiter ()
  {
    return recht.toString ().equals ("RechteMitarbeiter");
  }


  /**
   * 
   * @return ob der Benutzer ein Administrator ist
   */
  public boolean istAdministrator ()
  {
    return recht.toString ().equals ("RechteAdmin");
  }


  /**
   * 
   * @return ob der Benutzer ein Student ist
   */
  public boolean istStudent ()
  {
    return recht.toString ().equals ("RechteStudent");
  }


  /**
   * Liefert saemtliche Informationen ueber den Nutzer als String
   * 
   * @return gespeicherte Benutzer-Daten
   */
  public String toString ()
  {
    String ergebnis = "ID: " + id + "\n";
    ergebnis += super.toString ();
    if (geburtsname != null)
    {
      ergebnis += "\nGeburtsname: " + geburtsname;
    }
    if (!telefonnumernListe.isEmpty ())
    {
      ergebnis += "\nTelefonnummer: " + telefonnumernListe.get (0);
    }
    if (!emailListe.isEmpty ())
    {
      ergebnis += "\nE-Mail-Adresse: " + emailListe.get (0);
    }
    if (gebDatum != null)
    {
      ergebnis += "\nGeburtsdatum: " + gebDatum;
    }
    ergebnis += "\nRecht: " + recht;
    if (loginName != null)
    {
      ergebnis += "\nLoginName: " + loginName + "\n";
      ergebnis += "Passwort: kann nicht ausgelesen werden!";
    }
    if (adresse != null)
    {
      /*
       * Speichern von saemtlichen Daten zur Adresse
       */
      ergebnis += "\nAdresse: ";
      Wohnsitzadresse adr = (Wohnsitzadresse) adresse;
      ergebnis += "\n\t" + adr.gibStrasse ();
      ergebnis += " " + adr.gibHausnummer ();
      ergebnis += "\n\t" + adr.gibPLZ ();
      ergebnis += " " + adr.gibOrt ();

    }

    return ergebnis;
  }


  /**
   * Erzeugt die fuer die Internationalisierung notwendige
   * Lokalisierungs-Klasse
   * 
   * @param sprache
   *          die verwendet werden soll
   */
  public void setzeSprache (String sprache)
  {
    lokal = new Sprachverwaltung (sprache).gibLokalisierung ();
  }


  /*
   * initialisiert die Listen-Attribute und speichert einige
   * default-Angaben automatisch
   */
  private void initialisieren ()
  {
    notizListe = new ArrayList<Notiz> ();
    telefonnumernListe = new ArrayList<Telefonnummer> ();
    setzeAdressListe (new ArrayList<Adresse> ());
    setzeEmailListe (new ArrayList<Email> ());
    setzeAusleihListe (new ArrayList<MedienVorgang> ());
    setzeReservierungsListe (new ArrayList<MedienVorgang> ());
    setzeRechte (new RechteStandard ());
    setzeId (BenutzerNummernGenerator.gibNeueNummer ());
    setzeAuthentifizierung (new Benutzer.Authentifizierung ());

    /*
     * Sprache abfragen und speichern
     */
    Sprachen sprache = Dashboard.verwendeteSprache ();
    setzeSprache (sprache.toString ());
  }


  /*
   * Diese Methode ermoeglicht das Suchen eines Vorgangs
   */
  private MedienVorgang findeVorgang (Exemplar exemplar, String typ)
  {
    List<MedienVorgang> sammlung = new ArrayList<MedienVorgang> ();
    Exemplar gefExemplar;
    boolean gefunden = false;
    MedienVorgang vorgang = null;

    switch (typ.charAt (0))
    {
    case 'r':
    case 'R':
      sammlung = reservierungsListe;
      break;
    case 'a':
    case 'A':
      sammlung = ausleihListe;
      break;
    default:
      throw new UngueltigerTypAusnahme ();
    }

    /*
     * die Suche in den beim Benutzer gespeicherten Listen
     */
    for (int i = 0; i < sammlung.size () && !gefunden; i++)
    {
      vorgang = sammlung.get (i);
      gefExemplar = vorgang.gibExemplar ();
      EAN13 barcode = exemplar.gibBarcode ();
      EAN13 gefBarcode = gefExemplar.gibBarcode ();
      if ((gefExemplar.equals (exemplar))
          || (barcode.equals (gefBarcode)))
      {
        gefunden = true;
      }
    }
    if ((!gefunden) || (vorgang == null))
    {
      if (lokal != null)
      {
        throw new EintragNichtGefundenAusnahme (
            lokal.gibUebersetzung ("Exemplar nicht gefunden"));
      }
      else
      {
        throw new EintragNichtGefundenAusnahme (
            "Exemplar nicht gefunden!");
      }
    }
    return vorgang;
  }


  public Benutzer.Authentifizierung gibAuthentifizierung ()
  {
    return authentifizierung;
  }


  public void setzeAuthentifizierung (
      Benutzer.Authentifizierung authentifizierung)
  {
    this.authentifizierung = authentifizierung;
  }

  /*
   * Die innere Klasse Authentifizierung ist dafuer zustaendig, dass nur
   * zugelassene Benutzer das System der Bibliothek benutzen koennen.
   * Die Authentifizierungs-Klasse ubernimmt dabei die Pruefung, ob das
   * vom Benutzer eingegebene Passwort richtig ist. Ausserdem erzeugt
   * und aendert die Authentifizierung das vom Benutzer festgelegte
   * Passwort, wenn eine dementsprechende Anfrage gestellt wird. Das
   * Passwort wird in einen Hash-Wert umgerechnet und so verschluesselt
   * im Benutzer gespeichert.
   */

  public class Authentifizierung
  {

    public Authentifizierung ()
    {

    }


    /**
     * Methode fuer das erste Setzen eines Passwortes
     * 
     * @param passwort
     *          das der Benutzer ausgewaehlt hat
     */
    public void passwortSetzen (String passwort)
    {
      /*
       * Parameter ueberpruefen
       */
      if (passwort == null)
      {
        throw new ParameterIstNullAusnahme ();
      }

      /*
       * Ueberpruefen, ob tatsaechlich noch kein Passwort gesetzt wurde
       */
      if (gibLoginPasswort () != null)
      {
        throw new PasswortBereitsGesetztAusnahme ();
      }

      Integer psw = passwort.hashCode ();
      String loginPasswort = psw.toString ();
      setzeLoginPasswort (loginPasswort);
    }


    /**
     * Methode fuer das erste Setzen eines Passwortes
     * 
     * @param altesPasswort
     *          das bisherige Passwort des Benutzers
     * @param neuesPasswort
     *          das neue Passwort des Benutzers
     * @param neuesPasswortWiederholung
     *          die erneute Eingabe des Passworts
     */
    public void passwortAendern (String altesPasswort,
        String neuesPasswort, String neuesPasswortWiederholung)
    {
      /*
       * Parameter ueberpruefen
       */
      if ((altesPasswort == null) || (neuesPasswort == null)
          || (neuesPasswortWiederholung == null))
      {
        throw new ParameterIstNullAusnahme ();
      }

      /*
       * Ueberpruefen, ob das neue Passwort und die Wiederholung
       * uebereinstimmen
       */
      if (!neuesPasswort.equals (neuesPasswortWiederholung))
      {
        Benutzermeldung.fehlermeldungZeigen (
            lokal.gibUebersetzung ("Passwortwiederholung falsch"),
            lokal.gibUebersetzung ("Fehler"));
        throw new PasswortUndPasswortWiederholungSindUngleichAusnahme ();
      }

      /*
       * Ueberpruefen, ob das alte Passwort korrekt war
       */
      if (!passwortRichtig (altesPasswort))
      {
        Benutzermeldung.fehlermeldungZeigen (
            lokal.gibUebersetzung ("Altes Passwort falsch"),
            lokal.gibUebersetzung ("Fehler"));

        throw new PasswortFalschAusnahme (
            lokal.gibUebersetzung ("Altes Passwort falsch"));
      }

      String loginPasswort = Integer.toString (
	  neuesPasswort.hashCode ());
      setzeLoginPasswort (loginPasswort);
    }


    /**
     * Methode ueberprueft, ob das richtige Passwort zum Benutzer
     * eingegeben wurde
     * 
     * @param passwort
     *          das der Benutzer eingegeben hat
     * 
     * @return ob das Passwort mit dem bei dem Benutzer hinterlegten
     *         uebereinstimmt
     */
    public boolean passwortRichtig (String passwort)
    {
      /*
       * Parameter ueberpruefen
       */
      if (passwort == null)
      {
        throw new ParameterIstNullAusnahme ();
      }

      /*
       * das gespeicherte Passwort mit der Eingabe vergleichen
       */
      String gespPassw = gibLoginPasswort ();
      String pswHash = Integer.toString (passwort.hashCode ());
      if (gespPassw.equals (pswHash))
      {
        return true;
      }
      else
      {
        return false;
      }
    }

  }
}
